package com.atguigu.gulimall.search.Thread;

import java.util.Timer;
import java.util.concurrent.*;

public class ThreadTest1 {

    public static ExecutorService executors = Executors.newFixedThreadPool(10);//线程池

//    public static void main(String[] args) {
//        System.out.println("start main....");
//        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {//void 没有返回值
//            System.out.println("当前线程...");
//            int i = 10 / 2;
//            System.out.println("运行结果"+i);
//            System.out.println("当前线程号"+Thread.currentThread());
//        }, executors);
//        System.out.println("end main ");
//        System.out.println("main当前线程号"+Thread.currentThread()); //运行后进程还是一直在阻塞，因为线程池在创建运行
//    }


//    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        System.out.println("start main....");
//        CompletableFuture<Integer> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
//            System.out.println("当前线程...");
//            int i = 10 / 2;
//            System.out.println("运行结果"+i);
//            System.out.println("当前线程号"+Thread.currentThread());
//
//            return i;
//        }, executors);
//        System.out.println("end main ");
//        System.out.println("main当前线程号"+Thread.currentThread()+"值"+voidCompletableFuture.get());//阻塞获取
//    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Object> future1 = CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
            System.out.println("线程任务1执行");
            int i = 10 / 4;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程任务1结束");
            return i;
        }, executors);

        CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
            System.out.println("线程任务2执行");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程任务2结束");
            return "hello";
        }, executors);


        CompletableFuture<Object> future3 = CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
            System.out.println("线程任务3执行");
            System.out.println("线程任务3结束");
            return "world";
        }, executors);

        CompletableFuture<Void> allof = CompletableFuture.allOf(future1, future2, future3);
        System.out.println("main off"+allof.get());//allof.get() 等待所有线程都执行了 线程是并行的




//        future1.runAfterEitherAsync(future2,()->{//runAfterEitherAsync 只要任务1，2有一个执行完毕就可以执行任务3
//            System.out.println("线程任务3执行");
//        },executors);
//        future1.acceptEitherAsync(future2,(res)->{//acceptEitherAsync 能够感知任务1，2返回的结果
//            System.out.println("线程任务3执行结果"+res);
//        },executors);
//        CompletableFuture<String> future3 = future1.applyToEitherAsync(future2, (res) -> {//applyToEitherAsync 能够感知1，2的结果也能返回结果
//            System.out.println("线程任务3执行...");
//            return "任务3执行结果" + res;
//        }, executors);
//        System.out.println("main end ..."+future3.get());

//        future1.runAfterBothAsync(future2,()->{//runAfterBothAsync 1,2执行完再执行3
//            System.out.println("线程任务3执行...");
//        },executors);
//        future1.thenAcceptBothAsync(future2,(f1,f2)->{//thenAcceptBothAsync可以获取到线程1，2的返回值
//            System.out.println("线程任务3执行...");
//            System.out.println(f1);
//            System.out.println(f2);
//        },executors);
//        CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (f1, f2) -> {//thenCombineAsync 获取到1，2的返回结果后再执行3且有返回结果 使用get获取
//            return f1 + "-->" + f2;
//        }, executors);
//
//        System.out.println(future3.get());
//
//        System.out.println("main end ...");



//        CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
//            System.out.println("run1");
//            float  a = 10/0;
//            return 2;
//        }, executors).thenRunAsync(()->{//thenRunAsync是按照顺序执行的，如果1出现异常就执行不了，也补货补了异常
//            System.out.println("run2");
//        });


//        CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
//            System.out.println("run1");
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            return 2;
//        }, executors).thenAcceptAsync((res)->{//串行执行 能否取得1返回的结果，如果1有异常会中断执行
//            System.out.println("结果"+res);
//        });



//        System.out.println("start main....");
//        CompletableFuture<Integer> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {//有返回值 使用get阻塞获取
//            System.out.println("当前线程...");
//            int i = 10 / 0;
//            System.out.println("运行结果"+i);
//            System.out.println("当前线程号"+Thread.currentThread());
//
//            return i;
//        }, executors).handle((res,error)->{//感知异常，并且处理结果
//            System.out.println("当前线程号"+Thread.currentThread()+"异常错误"+error);
//            if(res != null){
//                return res;
//            }
//            return 1;
//        });
////                .whenComplete((res,exception)->{
////            //虽然得到返回结果，但是没法修改结果
////            System.out.println("执行完成 结果"+res+"异常"+exception);
////        }).exceptionally(exception->{//可以感知异常，同时返回默认值
////            System.out.println("感知异常"+exception);
////            return 10;
////        });
//        System.out.println("end main ");
//        System.out.println("main当前线程号"+Thread.currentThread()+"值"+voidCompletableFuture.get());//get阻塞获取线程的返回值
    }


}

